const fs = require('fs');
const path = require('path');

// 配置项
const config = {
    // 需要忽略的文件夹或文件名
    ignore: ['assets', 'en', 'public'],
    // 需要包含的文件扩展名（空数组表示包含所有文件）
    includeExtensions: ['md'],
    // 是否显示文件大小
    showFileSize: false,
    // 是否显示最后修改时间
    showModifiedTime: false
};

/**
 * 递归读取目录
 * @param {string} dirPath 目录路径
 * @param {number} depth 当前深度
 * @returns {Array} 目录树结构
 */
function readDirectory(dirPath, depth = 0) {
    try {
        const items = fs.readdirSync(dirPath);
        const result = [];
        const res = {}

        items.forEach(item => {
            // 跳过忽略的文件/文件夹
            if (config.ignore.includes(item)) return;

            const fullPath = path.join(dirPath, item);
            const stats = fs.statSync(fullPath);
            const isDirectory = stats.isDirectory();

            // 检查文件扩展名
            if (!isDirectory && config.includeExtensions.length > 0) {
                const ext = path.extname(item).slice(1);
                if (!config.includeExtensions.includes(ext)) return;
            }    

            const node = {
                name: item,
                path: item,
                type: isDirectory ? 'directory' : 'file',
                depth: depth
            };

            if (!isDirectory) {
                
                const {menu1, menu2} = readFileContent(fullPath);
                node.menu1= menu1
                node.menu2= menu2
            }

            // 添加额外信息
            if (config.showFileSize) {
                node.size = stats.size;
            }
            if (config.showModifiedTime) {
                node.modified = stats.mtime;
            }

            // 如果是目录，递归读取子目录
            if (isDirectory) {
                node.children = readDirectory(fullPath, depth + 1);
            }

            result.push(node);
        });

        return result;
    } catch (error) {
        console.error(`读取目录失败: ${dirPath}`, error);
        return [];
    }
}


// 定义一个异步函数来读取文件
function readFileContent(fullPath) {
    const res = {menu1: '', menu2: ''}

  try {
    // 2. 定义文件路径
    const filePath = path.join(__dirname, `../${fullPath}`);
    // console.log(44, filePath);
    
    
    // 3. 使用 await 等待文件读取完成
    // 'utf8' 是编码格式，指定后返回的内容是字符串，否则是 Buffer
    const data = fs.readFileSync(filePath, 'utf8');
    
    // 4. 打印文件内容
    // console.log('文件内容 (使用 fs.promises):');
    // console.log(data);

    // 正在处理文件内容，获取 MENU_TITL
    const matches = data.match(/---([\s\S]*?)---/g);
    if (matches) {
        const contents = matches.map(match => match.replace(/---/g, '').trim());
        const chunk = contents[0].split('\n').map(item => item.split(':'))
        const map = new Map(chunk);
        
       res.menu1 = map.get('FIRST_SIDEBAR_TEXT')?.trim()
       res.menu2 = map.get('SECOND_SIDEBAR_TEXT')?.trim()

    }
       return res
       
    //  const lines = data.split('\n');
    //  console.log(111, lines);
     
    
  } catch (error) {
    // 5. 处理可能发生的错误（例如，文件不存在）
    console.error('读取文件时出错:', error);
  }
}

// 调用函数
// readFileContent();


/**
 * 格式化输出目录树
 * @param {Array} tree 目录树结构
 * @param {string} prefix 前缀
 */
function printTree(tree, prefix = '') {
    tree.forEach((node, index) => {
        const isLast = index === tree.length - 1;
        const currentPrefix = isLast ? '└── ' : '├── ';
        const nextPrefix = prefix + (isLast ? '    ' : '│   ');

        console.log(prefix + currentPrefix + node.name);

        if (node.children && node.children.length > 0) {
            printTree(node.children, nextPrefix);
        }
    });
}

// 使用示例
const targetPath = process.argv[2] || './src'; // 可以通过命令行参数指定路径，默认为当前目录
const directoryTree = readDirectory(targetPath);

// console.log(directoryTree);

const arr1 = directoryTree.filter(item => item.type === 'directory')

let sidebar = {}
arr1.forEach(one => {
    sidebar[`/${one.path}/`] = []

    let obj = {text: '', items: []}
    one.children.forEach(t => {
        if (t.type === 'directory') {
            let obj1 = {text: '', items: []}
            t.children.forEach(s => {
                 if (s.path.includes('index.md')) {
                    obj1.text = s.menu1 || `标题一${t.path}`
                    obj1.items.unshift({text: s.menu2 || `标题二${s.path}`, link: `/${one.path}/${t.path}/${s.path}`})
                 } else {
                     obj1.items.push({text: s.menu2 || `标题二${s.path}`, link: `/${one.path}/${t.path}/${s.path}`})
                 }
                 
            })
            if (obj1.text) {
                sidebar[`/${one.path}/`].push(obj1)
            }
        } else {
            
            if (t.path.includes('index.md')) {
                obj.text = t.menu1 || `标题一${one.path}`
                obj.items.unshift({text: t.menu2 || `标题二${t.path}`, link: `/${one.path}/${t.path}`})
            } else {
                 obj.items.push({text: t.menu2 || `标题二${t.path}`, link: `/${one.path}/${t.path}`})
            }
        }
        
        if (obj.text) {
            sidebar[`/${one.path}/`].push(obj)
        }
    })
})

// console.dir(sidebar);

const dirPath = path.join(__dirname, '../.vitepress')


fs.writeFileSync(`${dirPath}/sidebar.json`, JSON.stringify(sidebar, null, 2));

console.log('\n已将菜单结构保存 .vitepress/sidebar.json');



// // 输出结果
// console.log('\n sidebar 结果：');
// printTree(sidebar);

// 如果需要将结果保存为JSON文件
// fs.writeFileSync('directory-tree.json', JSON.stringify(directoryTree, null, 2));
